package demo1;

public class DynamicArray<E> {

    private E[] data;//定义一个动态的数组
    private int size;//定义数组中的有效个数

    //调用构造方法进行初始化
    public DynamicArray(int capacity) {
         data = (E[])new Object[capacity];
         this.size =0;
    }
    public DynamicArray() {
        this(10);//初始化容量为10
    }

    // 获取数组的容量
    public int getCapacity() {
        return data.length;
    }

    // 获取数组中的元素个数
    public int getSize() {
        return size;
    }

    // 返回数组是否为空
    public boolean isEmpty() {
        return this.size ==0;//主要是根据数组中有效的个数来判定数组是否为空
    }

    // 在index索引的位置插入一个新元素e
    public void add(int index, E e)  {
         //判断index合不合法
        if(index<0||index>this.size) {
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size.");
        }
        //满了需要增容
        if(this.data.length==this.size) {
            resize(2* data.length);
        }
        for(int i =this.size-1;i>=index;--i) {
            data[i+1] = data[i];
        }
        this.data[index] = e;
        size++;
    }

    // 向所有元素后添加一个新元素
    public void addLast(E e) {
       add(size,e);
    }

    // 在所有元素前添加一个新元素
    public void addFirst(E e) {
        add(0,e);
    }

    // 获取index索引位置的元素
    public E get(int index) {
        if(index<0||index>=this.size) {
            throw new IllegalArgumentException("get failed. Require index<0||index>=this.size.");
        }
         return data[index];
    }

    // 修改index索引位置的元素为e
    public void set(int index, E e) {
        if(index<0||index>=this.size) {
            throw new IllegalArgumentException("set failed. Require index<0||index>=this.size.");
        }
        data[index] =e;
    }

    // 查找数组中是否有元素e
    public boolean contains(E e) {
        for(int i =0;i<this.size;++i) {
            if(data[i].equals(e))
                return true;
        }
        return false;
    }

    // 查找数组中元素e所在的索引，如果不存在元素e，则返回-1
    public int find(E e) {
        for(int i =0;i<this.size;++i) {
            if(data[i].equals(e))
                return i;
        }
        return -1;
    }

    // 从数组中删除index位置的元素, 返回删除的元素
    public E remove(int index) {
        //首先判断index处合不合法
        if(index<0||index>=this.size) {
            throw new IllegalArgumentException("get failed. Require index<0||index>=this.size.");
        }
        if(isEmpty()) {
            throw new IllegalArgumentException("数组为空");
        }
       //删除index下标的元素
        E ret = data[index];
        for(int i =index+1;i<this.size;++i) {
            data[i-1] = data[i];
        }
        size--;
        data[size]=null;
        //缩小容量
        if(this.size==this.data.length/2){
            resize(this.data.length/2);
        }
       return ret;
    }
    // 从数组中删除第一个元素, 返回删除的元素
    public E removeFirst() {
        E ret = remove(0);
        return ret;
    }

    // 从数组中删除最后一个元素, 返回删除的元素
    public E removeLast() {
        E ret = remove(size-1);
        return ret;
    }

    // 从数组中删除元素e
    public void removeElement(E e) {
        //找到这个要删除元素的下标
        int index = find(e);
        if(index!=-1) {
            remove(index);
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for(int i =0;i<this.size;++i) {
            sb.append(data[i]);
            if(i!=this.size-1) {
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    // 将数组空间的容量变成newCapacity大小
    private void resize(int newCapacity) {
       E newData[] = (E[])new Object[newCapacity];
       for(int i =0;i<this.size;++i) {
           newData[i] = data[i];
       }
       data= newData;
    }
}
